package hashtable;

import java.time.temporal.Temporal;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * 哈希表的真正实现所在
 */
public class HashTab {
    //链表实现哈希表,用于整合多条链表
    List<EmpLinkedList> linkedTab = new ArrayList<EmpLinkedList>();

    /**
     * 为当前哈希表添加链表
     * @param list 欲添加的链表
     */
    public void addlist(EmpLinkedList list){
        linkedTab.add(list);
    }

    /**
     * 向哈希表中添加节点
      */
    public void addEmploy(Employer employer){
        switch(getHashvalue(employer.id)%4){
            //偷懒将链表规模降低
            case 0:linkedTab.get(0).add(employer);
                break;
            case 1:linkedTab.get(1).add(employer);
                break;
            case 2:linkedTab.get(2).add(employer);
                break;
            case 3:linkedTab.get(3).add(employer);
                break;
        }
    }
    /**
     * 移出节点
     */
  public void removeEmploy(int id){
      //首先定位出节点所在的链表,再将其移除
      switch(getHashvalue(id)%4){
          //偷懒将链表规模降低
          case 0:linkedTab.get(0).remove(id);
              break;
          case 1:linkedTab.get(1).remove(id);
              break;
          case 2:linkedTab.get(2).remove(id);
              break;
          case 3:linkedTab.get(3).remove(id);
              break;
      }
  }
    /**
     * 移除list链表
     * @param list
     */
    public void remove(EmpLinkedList list){
        linkedTab.remove(list);
    }
    /**
     * 遍历当前哈希表
     */
    public void show(){
        for (int i = 0; i < linkedTab.size(); i++) {
            System.out.println("当前链表:"+linkedTab.get(i).name);
            Employer temp = linkedTab.get(i).head;
            while(temp!=null){
                System.out.println(temp);
                temp=temp.next;
            }
        }
    }
    /**
     * 获取employer哈希函数值
     * @param id 欲获取哈希值得对象的id
     */
    public int getHashvalue(int id){
        return id%linkedTab.size();
    }
}
class EmpLinkedList {
    Employer head;
    Employer temp;
    String name;

    public EmpLinkedList(String name) {
        this.name = name;
    }

    /**
     * 该方法用于为当前链表插入节点
     * @param employer 欲插入节点
     */
    public void add(Employer employer){
        if (head==null){
            head=employer;
        }else{
            temp=head;
            while(temp.next!=null){
                //不是最后一个节点
                if (temp.next.id>employer.id){
                    //从小到大依次插入,找到第一个比待插入节点id大的节点,插到他前面
                    break;
                }
                temp=temp.next;
            }
            employer.next=temp.next;
            temp.next=employer;
        }
    }
    /**
     *移去id所对应的节点
     * @param id
     */
    public void remove(int id){
         temp=head;
         while(temp.next!=null){
             if (temp.next.id==id)
                 break;
             temp=temp.next;
         }
         if (temp.next==null){
             //没找到
             System.out.println("在当前链表没有找到对应的节点");
         }else{
             temp.next=temp.next.next;
         }
    }

    /**
     * 该方法用于遍历当前链表,并将其节点输出
     */
    public void show(){
        temp=head;
        while(temp!=null){
            System.out.println(temp);
            temp=temp.next;
        }
    }
}
/**
 * 员工类(节点类)
 */
class Employer {
    public int id;
    public String name;
    public Employer next;

    public Employer(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Employer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}